home *** CD-ROM | disk | FTP | other *** search
/ BCI NET 2 / BCI NET 2.iso / archives / programming / misc / amigem.lha / amigem / exec / semaphores.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-19  |  5.7 KB  |  234 lines
  1. #include <exec/execbase.h>
  2. #include <exec/memory.h>
  3. #include <exec/semaphores.h>
  4. #include <exec/devices.h>
  5. #include <exec/io.h>
  6. #include <clib/_exec.h>
  7.  
  8. #define SEMAPHORESIGF (0x8000)
  9.  
  10. #define SM_TYPE_OBTAIN    0
  11. #define SM_TYPE_PROCURE    1
  12.  
  13. #include <amigem/fd_lib.h>
  14. #define LIBBASE struct ExecBase *SysBase
  15.  
  16. FD1(93,VOID,InitSemaphore,struct SignalSemaphore *sem,A0)
  17. { 
  18.   sem->ss_WaitQueue.mlh_Head    =(struct MinNode *)&sem->ss_WaitQueue.mlh_Tail;
  19.   sem->ss_WaitQueue.mlh_Tail    =NULL;
  20.   sem->ss_WaitQueue.mlh_TailPred=(struct MinNode *)&sem->ss_WaitQueue.mlh_Head;
  21.   sem->ss_NestCount=0;
  22. }
  23.  
  24. FD1(94,VOID,ObtainSemaphore,struct SignalSemaphore *sem,A0)
  25. {
  26.   struct Task *me;
  27.   me=FindTask(NULL);
  28.   Forbid();
  29.     if(sem->ss_NestCount&&sem->ss_Owner!=me)
  30.     {
  31.       struct Message sm;
  32.       sm.mn_ReplyPort=(struct MsgPort *)me;
  33.       sm.mn_Node.ln_Type=SM_TYPE_OBTAIN;
  34.       sm.mn_Node.ln_Name=(char *)SM_EXCLUSIVE;
  35.       AddTail((struct List *)&sem->ss_WaitQueue,&sm.mn_Node);
  36.       Wait(SEMAPHORESIGF);
  37.     }
  38.     else
  39.       sem->ss_NestCount++;
  40.   Permit();
  41. } 
  42.  
  43. FD1(96,ULONG,AttemptSemaphore,struct SignalSemaphore *sem,A0)
  44. {
  45.   LONG ret=0;
  46.   struct Task *me;
  47.   me=FindTask(NULL);
  48.   Forbid();
  49.     if(!sem->ss_NestCount||sem->ss_Owner==me)
  50.     {
  51.       ObtainSemaphore(sem);
  52.       ret=1;
  53.     }
  54.   Permit();
  55.   return ret;
  56. } 
  57.     
  58. FD1(113,VOID,ObtainSemaphoreShared,struct SignalSemaphore *sem,A0)
  59. {
  60.   struct Task *me;
  61.   me=FindTask(NULL);
  62.   Forbid();
  63.     if(sem->ss_NestCount>0)
  64.     {
  65.       if(sem->ss_Owner!=me)
  66.       { 
  67.         struct Message sm;
  68.         sm.mn_ReplyPort=(struct MsgPort *)me;
  69.         sm.mn_Node.ln_Type=SM_TYPE_OBTAIN;
  70.         sm.mn_Node.ln_Name=(char *)SM_SHARED;
  71.         AddTail((struct List *)&sem->ss_WaitQueue,&sm.mn_Node);
  72.         Wait(SEMAPHORESIGF);
  73.       }
  74.       else
  75.         sem->ss_NestCount++;
  76.     }
  77.     else
  78.       sem->ss_NestCount--;
  79.   Permit();
  80. } 
  81.  
  82. FD1(120,ULONG,AttemptSemaphoreShared,struct SignalSemaphore *sem,A0)
  83. {
  84.   LONG ret=0;
  85.   struct Task *me;
  86.   me=FindTask(NULL);
  87.   Forbid();
  88.     if(sem->ss_NestCount<=0||sem->ss_Owner==me)
  89.     {
  90.       ObtainSemaphoreShared(sem);
  91.       ret=1;
  92.     }
  93.   Permit();
  94.   return ret;
  95. } 
  96.  
  97. FD1(95,VOID,ReleaseSemaphore,struct SignalSemaphore *sem,A0)
  98. { 
  99.   Forbid();
  100.     if(sem->ss_NestCount>0) /* I hold an exclusive lock */
  101.       sem->ss_NestCount--;
  102.     else                    /* A shared lock */
  103.       sem->ss_NestCount++;
  104.     if(!sem->ss_NestCount&&sem->ss_WaitQueue.mlh_Head->mln_Succ!=NULL)
  105.     { 
  106.       struct SemaphoreMessage *sm;
  107.       sm=(struct SemaphoreMessage *)sem->ss_WaitQueue.mlh_Head;
  108.       if(sm->ssm_Message.mn_Node.ln_Name!=(char *)SM_EXCLUSIVE)
  109.       { 
  110.         struct MinNode *mn;
  111.         mn=(struct MinNode *)sm;
  112.         while(mn->mln_Succ!=NULL)
  113.         { 
  114.           sm=(struct SemaphoreMessage *)mn;
  115.           mn=mn->mln_Succ;
  116.           if(sm->ssm_Message.mn_Node.ln_Type!=SM_EXCLUSIVE)
  117.           { 
  118.             Remove((struct Node *)sm);
  119.             if(sm->ssm_Message.mn_Node.ln_Type==SM_TYPE_OBTAIN)
  120.               Signal((struct Task *)sm->ssm_Message.mn_ReplyPort,SEMAPHORESIGF);
  121.             else
  122.               ReplyMsg(&sm->ssm_Message);
  123.             sem->ss_NestCount--;
  124.           }
  125.           sem->ss_Owner=NULL;
  126.         }
  127.       }
  128.       else
  129.       { 
  130.         Remove((struct Node *)sm);
  131.         if(sm->ssm_Message.mn_Node.ln_Type==SM_TYPE_OBTAIN)
  132.         {
  133.           sem->ss_Owner=(struct Task *)sm->ssm_Message.mn_ReplyPort;
  134.           Signal((struct Task *)sm->ssm_Message.mn_ReplyPort,SEMAPHORESIGF);
  135.         }
  136.         else
  137.         {
  138.           sem->ss_Owner=(struct Task *)&sm->ssm_Message.mn_ReplyPort->mp_SigTask;
  139.           ReplyMsg(&sm->ssm_Message);
  140.         }
  141.         sem->ss_NestCount++;
  142.       }
  143.     }
  144.   Permit();
  145. }
  146.  
  147. FD2(90,VOID,Procure,struct SignalSemaphore *sem,A0,struct SemaphoreMessage *sm,A1)
  148. {
  149.   sm->ssm_Message.mn_Length=sizeof(struct SemaphoreMessage);
  150.   Forbid();
  151.     if((ULONG)sm->ssm_Message.mn_Node.ln_Name==SM_SHARED?
  152.        AttemptSemaphoreShared(sem):AttemptSemaphore(sem))
  153.     {
  154.       sm->ssm_Semaphore=sem;
  155.       ReplyMsg(&sm->ssm_Message);
  156.     }
  157.     else
  158.       AddTail((struct List *)&sem->ss_WaitQueue,&sm->ssm_Message.mn_Node);
  159.   Permit();
  160. }
  161.  
  162. FD2(91,VOID,Vacate,struct SignalSemaphore *sem,A0,struct SemaphoreMessage *sm,A1)
  163. {
  164.   struct MinNode *mn;
  165.   Forbid();
  166.     mn=(struct MinNode *)sem->ss_WaitQueue.mlh_Head;
  167.     while(mn->mln_Succ!=NULL)
  168.     { 
  169.       if(sm==(struct SemaphoreMessage *)mn)
  170.       {
  171.         Remove((struct Node *)mn);
  172.         ReplyMsg(&sm->ssm_Message);
  173.         break;
  174.       }
  175.       mn=mn->mln_Succ;
  176.     }
  177.     if(mn->mln_Succ==NULL)
  178.       ReleaseSemaphore(sem);
  179.   Permit();
  180.   sm->ssm_Semaphore=NULL;
  181. }
  182.  
  183. /*
  184.  * It would be nice if we could use the ss_MultipleLink to arbitrate
  185.  * for all semaphores at once but the message semaphore mechanism
  186.  * won't let us do it :(
  187.  *
  188.  * There's no problem with it though since other tasks will have to
  189.  * arbitrate for the list in the same order we do. So the first
  190.  * semaphore in the list arbitrates for the whole list.
  191.  */
  192. FD1(97,VOID,ObtainSemaphoreList,struct List *sl,A0)
  193. {
  194.   struct Node *n;
  195.   n=sl->lh_Head;
  196.   while(n->ln_Succ!=NULL)
  197.   {
  198.     ObtainSemaphore((struct SignalSemaphore *)n);
  199.     n=n->ln_Succ;
  200.   }
  201. }
  202.  
  203. FD1(98,VOID,ReleaseSemaphoreList,struct List *sl,A0)
  204. {
  205.   struct Node *n;
  206.   n=sl->lh_Head;
  207.   while(n->ln_Succ!=NULL)
  208.   {
  209.     ReleaseSemaphore((struct SignalSemaphore *)n);
  210.     n=n->ln_Succ;
  211.   }
  212. }
  213.  
  214. FD1(100,VOID,AddSemaphore,struct SignalSemaphore *sem,A1)
  215. {
  216.   sem->ss_Link.ln_Type=NT_SIGNALSEM;
  217.   InitSemaphore(sem);
  218.   Forbid();
  219.     Enqueue(&SysBase->SemaphoreList,&sem->ss_Link);
  220.   Permit();
  221. }
  222.  
  223. FD1(101,VOID,RemSemaphore,struct SignalSemaphore *sem,A1)
  224. {
  225.   Forbid();
  226.     Remove(&sem->ss_Link);
  227.   Permit();
  228. }
  229.  
  230. FD1(99,struct SignalSemaphore *,FindSemaphore,STRPTR name,A1)
  231. { 
  232.   return (struct SignalSemaphore *)FindName(&SysBase->SemaphoreList,name);
  233. }
  234.